const express = require('express');
const cors = require('cors');
const fs = require('fs-extra');
const path = require('path');

const app = express();
const PORT = 3000;

// 中间件
app.use(cors());
app.use(express.json());
app.use(express.static('public'));

// 存储依赖关系数据
let dependencyData = null;

/**
 * 加载依赖关系数据
 */
async function loadDependencyData(useFiltered = false) {
    try {
        let dataPath;
        if (useFiltered) {
            dataPath = path.join(__dirname, 'output', 'visualization-data-filtered.json');
        } else {
            dataPath = path.join(__dirname, 'output', 'visualization-data.json');
        }
        
        if (await fs.pathExists(dataPath)) {
            dependencyData = await fs.readJson(dataPath);
            const dataType = useFiltered ? '过滤版本' : '完整版本';
            console.log(`已加载依赖关系数据 (${dataType}): ${dependencyData.nodes.length} 个节点, ${dependencyData.edges.length} 条边`);
            
            if (dependencyData.filterInfo) {
                console.log(`过滤信息: 移除了 ${dependencyData.filterInfo.superNodeIds.length} 个超级节点`);
            }
            
            return true;
        } else {
            console.log('未找到依赖关系数据文件，请先运行 analyzer.js');
            return false;
        }
    } catch (error) {
        console.error('加载依赖关系数据失败:', error);
        return false;
    }
}

/**
 * 获取依赖关系数据
 */
app.get('/api/dependencies', async (req, res) => {
    try {
        if (!dependencyData) {
            const loaded = await loadDependencyData();
            if (!loaded) {
                return res.status(404).json({ error: '未找到依赖关系数据，请先运行 analyzer.js' });
            }
        }
        
        res.json(dependencyData);
    } catch (error) {
        console.error('获取依赖关系失败:', error);
        res.status(500).json({ error: '获取依赖关系失败' });
    }
});

/**
 * 搜索节点
 */
app.get('/api/search', async (req, res) => {
    try {
        const query = req.query.q;
        if (!query || !dependencyData) {
            return res.json([]);
        }
        
        const results = dependencyData.nodes.filter(node => 
            node.label.toLowerCase().includes(query.toLowerCase()) ||
            node.id.toLowerCase().includes(query.toLowerCase()) ||
            node.file.toLowerCase().includes(query.toLowerCase())
        );
        
        res.json(results);
    } catch (error) {
        console.error('搜索失败:', error);
        res.status(500).json({ error: '搜索失败' });
    }
});

/**
 * 获取节点详情
 */
app.get('/api/node/:id', async (req, res) => {
    try {
        const nodeId = req.params.id;
        
        if (!dependencyData) {
            return res.status(404).json({ error: '数据未加载' });
        }
        
        const node = dependencyData.nodes.find(n => n.id === nodeId);
        
        if (!node) {
            return res.status(404).json({ error: '节点不存在' });
        }
        
        // 获取依赖此节点的其他节点
        const dependents = dependencyData.edges
            .filter(edge => edge.to === nodeId)
            .map(edge => dependencyData.nodes.find(n => n.id === edge.from))
            .filter(Boolean);
        
        // 获取此节点依赖的节点
        const dependencies = dependencyData.edges
            .filter(edge => edge.from === nodeId)
            .map(edge => dependencyData.nodes.find(n => n.id === edge.to))
            .filter(Boolean);
        
        res.json({
            ...node,
            dependents,
            dependencies
        });
    } catch (error) {
        console.error('获取节点详情失败:', error);
        res.status(500).json({ error: '获取节点详情失败' });
    }
});

/**
 * 重新加载数据
 */
app.post('/api/reload', async (req, res) => {
    try {
        const loaded = await loadDependencyData();
        if (loaded) {
            res.json({ message: '数据重新加载成功', count: dependencyData.nodes.length });
        } else {
            res.status(404).json({ error: '未找到依赖关系数据文件' });
        }
    } catch (error) {
        console.error('重新加载失败:', error);
        res.status(500).json({ error: '重新加载失败' });
    }
});

/**
 * 切换数据版本
 */
app.post('/api/switch-version', async (req, res) => {
    try {
        const { useFiltered } = req.body;
        const loaded = await loadDependencyData(useFiltered);
        
        if (loaded) {
            const version = useFiltered ? '过滤版本' : '完整版本';
            res.json({ 
                message: `已切换到${version}`, 
                count: dependencyData.nodes.length,
                version: version,
                filterInfo: dependencyData.filterInfo || null
            });
        } else {
            res.status(404).json({ error: '未找到依赖关系数据文件' });
        }
    } catch (error) {
        console.error('切换版本失败:', error);
        res.status(500).json({ error: '切换版本失败' });
    }
});

/**
 * 获取统计信息
 */
app.get('/api/stats', async (req, res) => {
    try {
        if (!dependencyData) {
            return res.status(404).json({ error: '数据未加载' });
        }
        
        res.json(dependencyData.stats);
    } catch (error) {
        console.error('获取统计信息失败:', error);
        res.status(500).json({ error: '获取统计信息失败' });
    }
});

// 启动服务器
app.listen(PORT, async () => {
    console.log(`可视化服务器运行在 http://localhost:${PORT}`);
    
    // 启动时自动加载数据
    await loadDependencyData();
});
